home *** CD-ROM | disk | FTP | other *** search
/ EnigmA Amiga Run 1996 June / EnigmA AMIGA RUN 08 (1996)(G.R. Edizioni)(IT)[!][issue 1996-06][EARSAN CD VII].iso / earcd / utilsys / rss14gmd.lha / RSys_1.4gmd / C / FindFile.c < prev    next >
C/C++ Source or Header  |  1996-05-04  |  19KB  |  766 lines
  1. /*
  2.    ***************************************************************************
  3.    *
  4.    * Datei:
  5.    *      RSysFindFile.c
  6.    *
  7.    * Inhalt:
  8.    *
  9.    *      --- Globale Routinen ---
  10.    *
  11.    *    void FindFile ( void );
  12.    *    void HandleFindFileKeys ( ULONG code );
  13.    *    void MakeDevEntry ( LIST *list , char *str );
  14.    *
  15.    *      --- Lokale  Routinen ---
  16.    *
  17.    *    static BOOL ClickedGadget ( void );
  18.    *    static int OpenFindFileWindow ( void );
  19.    *    static void *MyDevAllocRem ( long size );
  20.    *    static void *MyFileAllocRem ( long size );
  21.    *    static void HandleFindFileGadgets ( APTR object , ULONG code );
  22.    *    static void MakeDevList ( void );
  23.    *    static void MakeFileEntry ( char *str );
  24.    *    static void refreshdevlists ( void );
  25.    *    static void SaveFoundFiles ( void );
  26.    *    static void SearchFile ( char *name );
  27.    *
  28.    * Bemerkungen:
  29.    *      Disk-Format-Untersützung und Dateisuchroutinen.
  30.    *
  31.    * Erstellungsdatum:
  32.    *      07-Jul-93     Rolf Böhme
  33.    *
  34.    * Änderungen:
  35.    *      07-Jul-93     Rolf Böhme        Erstellung
  36.    *
  37.    ***************************************************************************
  38.  */
  39.  
  40. #include "RSys.h"
  41. #include "protos.h"
  42.  
  43. static int breakitx = FALSE;
  44.  
  45. static WINDOW *FindFileWnd = NULL;
  46. static GADGET *FindFileGList = NULL;
  47. static UWORD FindFileZoom[4];
  48. static GADGET *FindFileGadgets[10];
  49. static UWORD FindFileLeft = 153;
  50. static UWORD FindFileTop = 27;
  51. static UWORD FindFileWidth = 330;
  52. static UWORD FindFileHeight = 200;
  53. static UBYTE FindFileWdt[100];    /*GMD */
  54. static UBYTE *CaseCYGad0Labels[] =
  55. {
  56.   (UBYTE *) "No case sense",
  57.   (UBYTE *) "Case sense",
  58.   NULL
  59. };
  60. static UBYTE *DirFileCYGad0Labels[] =
  61. {
  62.   (UBYTE *) "Dirs + Files",
  63.   (UBYTE *) "Files",
  64.   (UBYTE *) "Directories",
  65.   NULL};
  66.  
  67. static LIST DevList;
  68. static LIST SelDevList, FoundList;
  69.  
  70. REMEMBER *DevKey = NULL;
  71. static REMEMBER *FileKey = NULL;
  72.  
  73. static char pat[PATTERNLEN], parsepat[PARSEPATLEN];
  74. static int match_case = NO_CASE, match_type = DF;
  75.  
  76. static UWORD FindFileGTypes[] =
  77. {
  78.   LISTVIEW_KIND,
  79.   LISTVIEW_KIND,
  80.   STRING_KIND,
  81.   BUTTON_KIND,
  82.   LISTVIEW_KIND,
  83.   BUTTON_KIND,
  84.   BUTTON_KIND,
  85.   BUTTON_KIND,
  86.   CYCLE_KIND,
  87.   CYCLE_KIND
  88. };
  89.  
  90. static NEWGADGET FindFileNGad[] =
  91. {
  92.   4, 17, 157, 60, (UBYTE *) "Devices", NULL, GD_DeviceLV, PLACETEXT_ABOVE, NULL, NULL,
  93.   168, 17, 157, 60, (UBYTE *) "Selected Devices", NULL, GD_SelDevLV, PLACETEXT_ABOVE | NG_HIGHLABEL, NULL, NULL,
  94.   74, 113, 87, 13, (UBYTE *) "Pattern", NULL, GD_PatternGad, PLACETEXT_LEFT, NULL, NULL,
  95.   4, 97, 157, 13, (UBYTE *) "Start/Stop Search", NULL, GD_StartStopGad, PLACETEXT_IN, NULL, NULL,
  96.   4, 144, 321, 52, (UBYTE *) "Found files/dirs", NULL, GD_FoundLV, PLACETEXT_ABOVE | NG_HIGHLABEL, NULL, NULL,
  97.   168, 97, 157, 13, (UBYTE *) "Save found list", NULL, GD_SaveFoundListGad, PLACETEXT_IN, NULL, NULL,
  98.   168, 81, 77, 13, (UBYTE *) "Sel all", NULL, GD_AllGad, PLACETEXT_IN, NULL, NULL,
  99.   248, 81, 77, 13, (UBYTE *) "Sel none", NULL, GD_NoneGad, PLACETEXT_IN, NULL, NULL,
  100.   4, 81, 157, 13, NULL, NULL, GD_CaseCYGad, 0, NULL, NULL,
  101.   168, 113, 157, 13, NULL, NULL, GD_DirFileCYGad, 0, NULL, NULL
  102. };
  103.  
  104. static ULONG *FindFileGTags[] =
  105. {
  106.   (ULONG *) (GTLV_Labels), (ULONG *) & DevList, (ULONG *) (TAG_DONE),
  107.   (ULONG *) (GTLV_Labels), (ULONG *) & SelDevList, (ULONG *) (TAG_DONE),
  108.   (ULONG *) (GTST_MaxChars), (ULONG *) 256, (ULONG *) (TAG_DONE),
  109.   (ULONG *) (GA_Disabled), (ULONG *) TRUE, (ULONG *) (TAG_DONE),
  110.   (ULONG *) (GTLV_Labels), (ULONG *) & FoundList, (ULONG *) (GTLV_ReadOnly), (ULONG *) TRUE, (ULONG *) (TAG_DONE),
  111.   (ULONG *) (TAG_DONE),
  112.   (ULONG *) (TAG_DONE),
  113.   (ULONG *) (TAG_DONE),
  114.   (ULONG *) (GTCY_Labels), (ULONG *) & CaseCYGad0Labels[0], (ULONG *) (TAG_DONE),
  115.   (ULONG *) (GTCY_Labels), (ULONG *) & DirFileCYGad0Labels[0], (ULONG *) (TAG_DONE)
  116. };
  117.  
  118. static int gl[] =
  119. {GD_DeviceLV - GD_DeviceLV,
  120.  GD_SelDevLV - GD_DeviceLV,
  121.  GD_PatternGad - GD_DeviceLV,
  122.  GD_FoundLV - GD_DeviceLV};
  123.  
  124.  /*
  125.   * OpenFindFileWindow() öffnet ein Window mit Gadgets, mit
  126.   * denen die Auswahl- und Suchkriterien eingegeben werden
  127.   * können
  128.   */
  129. static int
  130. OpenFindFileWindow (void)
  131. {
  132.   NEWGADGET ng;
  133.   GADGET *g;
  134.   UWORD lc, tc;
  135.   UWORD wleft = FindFileLeft, wtop = FindFileTop, ww, wh;
  136.  
  137.   DPOS;
  138.  
  139.   AdjustWindowDimensions (Scr, FindFileLeft, FindFileTop, FindFileWidth, FindFileHeight,
  140.               &wleft, &wtop, &ww, &wh);
  141.  
  142.   if (!(g = CreateContext (&FindFileGList)))
  143.     return 1L;
  144.  
  145.   for (lc = 0, tc = 0; lc < FindFile_CNT; lc++)
  146.     {
  147.       CopyMem ((char *) &FindFileNGad[lc], (char *) &ng, (long) sizeof (NEWGADGET));
  148.  
  149.       ng.ng_VisualInfo = VisualInfo;
  150.       ng.ng_TextAttr = Font;
  151.       ng.ng_LeftEdge = OffX + ComputeX (ng.ng_LeftEdge);
  152.       ng.ng_TopEdge = OffY + ComputeY (ng.ng_TopEdge);
  153.       ng.ng_Width = ComputeX (ng.ng_Width);
  154.       ng.ng_Height = ComputeY (ng.ng_Height);
  155.  
  156.       FindFileGadgets[lc] = g = CreateGadgetA ((ULONG) FindFileGTypes[lc], g, &ng, (TAGITEM *) & FindFileGTags[tc]);
  157.  
  158.       makelabelvisible (FindFileGadgets[lc]);
  159.  
  160.       while (FindFileGTags[tc])
  161.     tc += 2;
  162.       tc++;
  163.  
  164.       if (NOT g)
  165.     return 2L;
  166.     }
  167.  
  168.   strcpy (FindFileWdt, get_vers (" - Find File"));    /*GMD */
  169.  
  170.   FindFileZoom[2] = TextLength (&Scr->RastPort, (UBYTE *) FindFileWdt,
  171.                 strlen ((char *) FindFileWdt)) + 80;
  172.   FindFileZoom[0] = FindFileZoom[1] = 0;
  173.   FindFileZoom[3] = Scr->WBorTop + Scr->RastPort.TxHeight + 1;
  174.  
  175.   if (!(FindFileWnd = OpenWindowTags (NULL,
  176.                       WA_Left, wleft,
  177.                       WA_Top, wtop,
  178.                       WA_Width, ww,
  179.                       WA_Height, wh,
  180.                       WA_IDCMP, IDCMP_VANILLAKEY |
  181.                       LISTVIEWIDCMP |
  182.                       STRINGIDCMP |
  183.                       BUTTONIDCMP |
  184.                       CYCLEIDCMP |
  185.                       IDCMP_CLOSEWINDOW |
  186.                       IDCMP_CHANGEWINDOW |
  187.                       IDCMP_REFRESHWINDOW,
  188.                       WA_Flags, WFLG_DRAGBAR |
  189.                       WFLG_DEPTHGADGET |
  190.                       WFLG_CLOSEGADGET |
  191.                       WFLG_RMBTRAP |
  192.                       WFLG_ACTIVATE |
  193.                       WFLG_SMART_REFRESH,
  194.                       WA_Title, FindFileWdt,
  195.                       WA_Zoom, FindFileZoom,
  196.                       WA_PubScreenFallBack, TRUE,
  197.                       WA_PubScreen, Scr,
  198.                       TAG_DONE)))
  199.     return 4L;
  200.  
  201.   FindFileZoom[0] = FindFileWnd->LeftEdge;
  202.   FindFileZoom[1] = FindFileWnd->TopEdge;
  203.   FindFileZoom[2] = FindFileWnd->Width;
  204.   FindFileZoom[3] = FindFileWnd->Height;
  205.  
  206.   RefreshRastPort (FindFileWnd, FindFileGadgets, gl, 4, FALSE, FindFileGList);
  207.  
  208.   return NULL;
  209. }
  210.  
  211.  /*
  212.   * MyDevAllocRem() reserviert Speicher aus einer Remember-Liste
  213.   * für die Verzeichnis-Einträge
  214.   */
  215. static void *
  216. MyDevAllocRem (long size)
  217. {
  218.   void *ptr = (void *) AllocRemember (DEVKEY, size, MEMF_CLEAR | MEMF_ANY);
  219.  
  220.   if (NOT (ptr))
  221.     {
  222.       ErrorHandle ("Device list", MEMORY_ERR, ALLOC_FAIL, NO_KILL);
  223.       Flags.quit_ff = 1;
  224.     }
  225.  
  226.   return (ptr);
  227. }
  228.  
  229.  /*
  230.   * MyFileAllocRem() reserviert Speicher aus einer Remember-Liste
  231.   * für die Datei-Einträge
  232.   */
  233. static void *
  234. MyFileAllocRem (long size)
  235. {
  236.   void *ptr = (void *) AllocRemember (FILEKEY, size, MEMF_CLEAR | MEMF_ANY);
  237.  
  238.   if (NOT (ptr))
  239.     {
  240.       ErrorHandle ("File list", MEMORY_ERR, ALLOC_FAIL, NO_KILL);
  241.       Flags.quit_ff = 1;
  242.     }
  243.  
  244.   return (ptr);
  245. }
  246.  
  247.  /*
  248.   * refreshdevlists() erneuert die Anzeige der ListViews mit den
  249.   * Inhalten der Listen der selektierten und der nicht selektierten
  250.   * Devices
  251.   */
  252. static void
  253. refreshdevlists (void)
  254. {
  255.   InitListView (FindFileWnd, FindFileGadgets[GD_DeviceLV - GD_DeviceLV], &DevList, UNSETLVPOS);
  256.   InitListView (FindFileWnd, FindFileGadgets[GD_SelDevLV - GD_DeviceLV], &SelDevList, UNSETLVPOS);
  257.  
  258.   return;
  259. }
  260.  
  261.  /*
  262.   * MakeDevEntry() erzeugt einen neuen Listeneintrag in die
  263.   * Liste der Devices
  264.   */
  265. void
  266. MakeDevEntry (LIST * list, char *str)
  267. {
  268.   NODE *node = MyDevAllocRem (sizeof (NODE));
  269.  
  270.   if (NOT (node))
  271.     return;
  272.  
  273.   node->ln_Pri = 0;
  274.   node->ln_Type = NT_USER;
  275.  
  276.   node->ln_Name = MyDevAllocRem (strlen (str) + 1);
  277.   if (NOT (node->ln_Name))
  278.     return;
  279.  
  280.   strcpy (node->ln_Name, str);
  281.  
  282.   AddNodeSorted (list, node, 0);
  283.  
  284.   return;
  285. }
  286.  
  287.  /*
  288.   * MakeFileEntry() erzeugt einen Listeneintrag in die Liste der
  289.   * gefundenen Dateien. Der Eintrag wird dann in die bestehende
  290.   * Liste alphabetisch einsortiert
  291.   */
  292. static void
  293. MakeFileEntry (char *str)
  294. {
  295.   NODE *node = MyFileAllocRem (sizeof (NODE));
  296.  
  297.   if (NOT (node))
  298.     return;
  299.  
  300.   node->ln_Pri = 0;
  301.   node->ln_Type = NT_USER;
  302.   node->ln_Name = MyDevAllocRem (strlen (str) + 1);
  303.  
  304.   if (NOT (node->ln_Name))
  305.     return;
  306.  
  307.   strcpy (node->ln_Name, str);
  308.  
  309.   AddNodeSorted (&FoundList, node, 0);
  310.  
  311.   InitListView (FindFileWnd, FindFileGadgets[GD_FoundLV - GD_DeviceLV], &FoundList, UNSETLVPOS);
  312.  
  313.   return;
  314. }
  315.  
  316.  
  317.  /*
  318.   * MakeDevList() erzeugt eine Liste aus angemeldeten Devices
  319.   * (Volumes) und Assigns. Die Devices werden der Reihe nach
  320.   * ausgelesen und in die Liste einsortiert. Assigns werden mit
  321.   * einem führenden "-" versehen, damit sie in der Liste
  322.   * unterschieden werden können
  323.   */
  324. static void
  325. MakeDevList (void)
  326. {
  327.   char dev[80], str[100];
  328.   DOSLIST *dl;
  329.  
  330.   dl = LockDosList (LDF_VOLUMES | LDF_READ);
  331.  
  332.   while (dl = NextDosEntry (dl, LDF_VOLUMES | LDF_READ))
  333.     {
  334.       sprintf (str, " %s:", B2CStr (dev, dl->dol_Name));
  335.       MakeDevEntry (&DevList, str);
  336.     }
  337.  
  338.   UnLockDosList (LDF_VOLUMES | LDF_READ);
  339.  
  340.   dl = LockDosList (LDF_ASSIGNS | LDF_READ);
  341.  
  342.   while (dl = NextDosEntry (dl, LDF_ASSIGNS | LDF_READ))
  343.     {
  344.       sprintf (str, "\-%s:", B2CStr (dev, dl->dol_Name));
  345.       MakeDevEntry (&DevList, str);
  346.     }
  347.  
  348.   UnLockDosList (LDF_ASSIGNS | LDF_READ);
  349.  
  350.   return;
  351. }
  352.  
  353.  
  354.  /*
  355.   * ClickedGadget() prüft, ob das Start/Stop-Gadget betätigt
  356.   * wurde. Mit einem AutoRequester wird nachgefragt, ob die
  357.   * Suche nach Dateien eingestellt werden soll
  358.   */
  359. static BOOL
  360. ClickedGadget (void)
  361. {
  362.   INTUIMESSAGE *mess;
  363.   ULONG class;
  364.   APTR adr;
  365.   BOOL ret = FALSE;
  366.  
  367.   while ((mess = (INTUIMESSAGE *) GT_GetIMsg (FindFileWnd->UserPort)) != NULL)
  368.     {
  369.       class = mess->Class;
  370.       adr = mess->IAddress;
  371.  
  372.       GT_ReplyIMsg (mess);
  373.  
  374.       switch (class)
  375.     {
  376.     case IDCMP_CHANGEWINDOW:
  377.     case IDCMP_REFRESHWINDOW:
  378.       RefreshRastPort (FindFileWnd, FindFileGadgets, gl, 4, TRUE, NULL);
  379.       MakeWindowRefresh (FindFileWnd);
  380.       break;
  381.  
  382.     case IDCMP_GADGETUP:
  383.       if ((adr == (APTR) FindFileGadgets[GD_StartStopGad - GD_DeviceLV]) &&
  384.         Question (FindFileWnd, "Do you want to cancel searching?", YES))
  385.         {
  386.           ret = TRUE;
  387.           breakitx = TRUE;
  388.         }
  389.       break;
  390.     }
  391.     }
  392.  
  393.   return ret;
  394. }
  395.  
  396.  /*
  397.   * SearchFile() wird rekursiv mit dem dem Namen eines
  398.   * Verzeichnisses oder Devices aufgerufen. Es durchsucht dann
  399.   * alle Verzeichnisse nach vorgegebenem Suchmuster. Die
  400.   * gefundenen Einträge werden in die entsprechenden Listen
  401.   * eingetragen
  402.   */
  403. static void
  404. SearchFile (char *name)
  405. {
  406.   EXALLCONTROL *eac;
  407.   EXALLDATA *EAData, *ead;
  408.   int more;
  409.   BPTR lock;
  410.   UBYTE newdir[MAXFULLNAME], foundname[MAXFULLNAME];
  411.   BOOL (*matchfunc[2]) (UBYTE *, UBYTE *) =
  412.   {
  413.     MatchPatternNoCase, MatchPattern
  414.   };
  415.  
  416.   if (ClickedGadget () || breakitx || Flags.quit_ff)
  417.     return;
  418.  
  419.   if (NOT (lock = Lock ((UBYTE *) name, ACCESS_READ)))
  420.     return;
  421.  
  422.   if (eac = AllocDosObject (DOS_EXALLCONTROL, NULL))
  423.     {
  424.       eac->eac_LastKey = 0;
  425.  
  426.       EAData = MyAllocVec ((MAXLARGEMEM + 1) * sizeof (EXALLDATA),
  427.                MEMF_ANY | MEMF_CLEAR, NO_KILL);
  428.  
  429.       if (EAData)
  430.     {
  431.       do
  432.         {
  433.           more = ExAll (lock, EAData, MAXLARGEMEM * sizeof (EXALLDATA),
  434.                 ED_SIZE, eac);
  435.  
  436.           if ((!more) && (IoErr () != ERROR_NO_MORE_ENTRIES))
  437.         {
  438.           ErrorHandle (name, DOS_EXALL_ERR, EXALL_FAIL, NO_KILL);
  439.           break;
  440.         }
  441.  
  442.           if (eac->eac_Entries == 0)
  443.         continue;
  444.  
  445.           ead = EAData;
  446.  
  447.           do
  448.         {
  449.           if ((*matchfunc[match_case]) ((UBYTE *) parsepat,
  450.                      FilePart ((UBYTE *) ead->ed_Name)))
  451.             {
  452.               strncpy ((char *) foundname, name, MAXFULLNAME);
  453.               if (AddPart (foundname, ead->ed_Name, MAXFULLNAME))
  454.             {
  455.               if (ead->ed_Type > 0)
  456.                 strcat ((char *) foundname, " (dir)");
  457.  
  458.               if ((match_type == DF) || ((match_type == FI) && (ead->ed_Type <= 0)) ||
  459.                   ((match_type == DI) && (ead->ed_Type > 0)))
  460.                 MakeFileEntry ((char *) foundname);
  461.             }
  462.             }
  463.  
  464.           if (ead->ed_Type > 0)
  465.             {
  466.               strncpy ((char *) newdir, name, MAXFULLNAME);
  467.  
  468.               if (AddPart (newdir, ead->ed_Name, MAXFULLNAME))
  469.             SearchFile ((char *) newdir);
  470.             }
  471.  
  472.           ead = ead->ed_Next;
  473.         }
  474.           while (ead && NOT (ClickedGadget ()) && NOT (breakitx) && NOT (Flags.quit_ff));
  475.  
  476.         }
  477.       while (more);
  478.  
  479.       MyFreeVec (EAData);
  480.     }
  481.  
  482.       FreeDosObject (DOS_EXALLCONTROL, eac);
  483.     }
  484.   else
  485.     ErrorHandle ("ExAll()-Control", MEMORY_ERR, ALLOC_FAIL, NO_KILL);
  486.  
  487.   UnLock (lock);
  488.  
  489.   return;
  490. }
  491.  
  492.  /*
  493.   * SaveFoundFiles() speichert die Liste mit den gefunden
  494.   * Dateien und Verzeichnissen in einer Datei ab
  495.   */
  496. static void
  497. SaveFoundFiles (void)
  498. {
  499.   char head[PARSEPATLEN];
  500.  
  501.   if (GetFile (FindFileWnd, "RAM:", "RSys-FoundFiles.DAT", "#?.DAT",
  502.            "Select File for saving list", "Save"))
  503.     {
  504.       sprintf (head, "Found files (Pattern: %s)", pat);
  505.       SaveList (FindFileWnd, (char *) _fullpath, head, &FoundList, FALSE);
  506.     }
  507.  
  508.   return;
  509. }
  510.  
  511. static void
  512. HandleFindFileGadgets (APTR object, ULONG code)
  513. {
  514.   NODE *clicknode, *node, *remnode;
  515.   int ID, i;
  516.   LONG (*parse_func[2]) (UBYTE *, UBYTE *, long) =
  517.   {
  518.     ParsePatternNoCase, ParsePattern
  519.   };
  520.  
  521.   DPOS;
  522.  
  523.   ID = ((GADGET *) object)->GadgetID;
  524.  
  525.   HandleHelp ((enum RSysNumbers) ID);
  526.  
  527.   switch (ID)
  528.     {
  529.     case GD_DeviceLV:
  530.       clicknode = GetNode (&DevList, code);
  531.       Remove (clicknode);
  532.       AddTail (&SelDevList, clicknode);
  533.       refreshdevlists ();
  534.  
  535.       if (strlen (pat))
  536.     EnableGadget (FindFileWnd, FindFileGadgets[GD_StartStopGad - GD_DeviceLV], TRUE);
  537.       break;
  538.  
  539.     case GD_SelDevLV:
  540.       clicknode = GetNode (&SelDevList, code);
  541.       Remove (clicknode);
  542.       AddNodeSorted (&DevList, clicknode, 0);
  543.       refreshdevlists ();
  544.  
  545.       if (IsListEmpty (&SelDevList))
  546.     EnableGadget (FindFileWnd, FindFileGadgets[GD_StartStopGad - GD_DeviceLV], FALSE);
  547.       break;
  548.  
  549.     case GD_PatternGad:
  550.       strncpy (pat, gadgetbuff (FindFileGadgets[GD_PatternGad - GD_DeviceLV]), PATTERNLEN);
  551.  
  552.       if (strlen (pat) == 0)
  553.     EnableGadget (FindFileWnd, FindFileGadgets[GD_StartStopGad - GD_DeviceLV], FALSE);
  554.       else if ((*parse_func[match_case]) ((UBYTE *) pat, (UBYTE *) parsepat, 162) < 0)
  555.     EnableGadget (FindFileWnd, FindFileGadgets[GD_StartStopGad - GD_DeviceLV], FALSE);
  556.       else if (NOT (IsListEmpty (&SelDevList)))
  557.     EnableGadget (FindFileWnd, FindFileGadgets[GD_StartStopGad - GD_DeviceLV], TRUE);
  558.  
  559.       break;
  560.  
  561.     case GD_StartStopGad:
  562.       if (NOT (IsListEmpty (&SelDevList)))
  563.     {
  564.       if (NOT (IsListEmpty (&FoundList)) && Question (FindFileWnd, "File list not empty!\n"
  565.                          "Do you want to save it?", NO))
  566.         SaveFoundFiles ();
  567.  
  568.       InitListView (FindFileWnd, FindFileGadgets[GD_FoundLV - GD_DeviceLV], NULL, 0);
  569.  
  570.       FreeRemember (FILEKEY, TRUE);
  571.       NewList (&FoundList);
  572.  
  573.       InitListView (FindFileWnd, FindFileGadgets[GD_FoundLV - GD_DeviceLV], &FoundList, UNSETLVPOS);
  574.  
  575.       for (i = GD_DeviceLV; i <= GD_DirFileCYGad; i++)
  576.         if ((i != GD_StartStopGad) && (i != GD_FoundLV))
  577.           EnableGadget (FindFileWnd, FindFileGadgets[i - GD_DeviceLV], FALSE);
  578.  
  579.       breakitx = FALSE;
  580.  
  581.       for (node = SelDevList.lh_Head; node->ln_Succ; node = node->ln_Succ)
  582.         SearchFile (&(node->ln_Name)[1]);
  583.  
  584.       for (i = GD_DeviceLV; i <= GD_DirFileCYGad; i++)
  585.         if ((i != GD_StartStopGad) && (i != GD_FoundLV))
  586.           EnableGadget (FindFileWnd, FindFileGadgets[i - GD_DeviceLV], TRUE);
  587.     }
  588.       break;
  589.  
  590.     case GD_SaveFoundListGad:
  591.       if (NOT (IsListEmpty (&FoundList)))
  592.     SaveFoundFiles ();
  593.       break;
  594.  
  595.     case GD_AllGad:
  596.       if (IsListEmpty (&DevList))
  597.     break;
  598.  
  599.       node = DevList.lh_Head;
  600.       while (node->ln_Succ)
  601.     {
  602.       remnode = node->ln_Succ;
  603.       Remove (node);
  604.       AddTail (&SelDevList, node);
  605.       node = remnode;
  606.     }
  607.  
  608.       InitListView (FindFileWnd, FindFileGadgets[GD_DeviceLV - GD_DeviceLV], NULL, 0);
  609.       NewList (&DevList);
  610.  
  611.       refreshdevlists ();
  612.       if (strlen (pat))
  613.     EnableGadget (FindFileWnd, FindFileGadgets[GD_StartStopGad - GD_DeviceLV], TRUE);
  614.       break;
  615.  
  616.     case GD_NoneGad:
  617.       if (IsListEmpty (&SelDevList))
  618.     break;
  619.  
  620.       node = SelDevList.lh_Head;
  621.       while (node->ln_Succ)
  622.     {
  623.       remnode = node->ln_Succ;
  624.       Remove (node);
  625.       AddNodeSorted (&DevList, node, 0);
  626.       node = remnode;
  627.     }
  628.  
  629.       InitListView (FindFileWnd, FindFileGadgets[GD_SelDevLV - GD_DeviceLV], NULL, 0);
  630.       NewList (&SelDevList);
  631.  
  632.       refreshdevlists ();
  633.       EnableGadget (FindFileWnd, FindFileGadgets[GD_StartStopGad - GD_DeviceLV], FALSE);
  634.  
  635.       break;
  636.  
  637.     case GD_CaseCYGad:
  638.       match_case = ((match_case == CASE) ? NO_CASE : CASE);
  639.       if (strlen (pat) == 0)
  640.     EnableGadget (FindFileWnd, FindFileGadgets[GD_StartStopGad - GD_DeviceLV], FALSE);
  641.       else if ((*parse_func[match_case]) ((UBYTE *) pat, (UBYTE *) parsepat, 162) < 0)
  642.     EnableGadget (FindFileWnd, FindFileGadgets[GD_StartStopGad - GD_DeviceLV], FALSE);
  643.       else
  644.     EnableGadget (FindFileWnd, FindFileGadgets[GD_StartStopGad - GD_DeviceLV], TRUE);
  645.       break;
  646.  
  647.     case GD_DirFileCYGad:
  648.       match_type = code;
  649.       break;
  650.     }
  651.  
  652.   return;
  653. }
  654.  
  655. void
  656. HandleFindFileKeys (ULONG code)
  657. {
  658.   if (code == ESC)
  659.     {
  660.       if (NOT (IsListEmpty (&FoundList)) && Question (FindFileWnd, "File list not empty!\n"
  661.                          "Do you want to save it?", NO))
  662.     SaveFoundFiles ();
  663.  
  664.       Flags.quit_ff = 1;
  665.     }
  666.  
  667.   return;
  668. }
  669.  
  670.  /*
  671.   * FindFile() präsentiert eine Benutzeroberfläche, mit der die
  672.   * Suchkriterien eingestellt und das Handling gemanagt wird
  673.   */
  674. void
  675. FindFile (void)
  676. {
  677.   INTUIMESSAGE *message;
  678.   ULONG class, code;
  679.   APTR object;
  680.   static int refr = TRUE;
  681.  
  682.   DPOS;
  683.  
  684.   HandleHelp (MN_FindFile);
  685.  
  686.   NewList (&DevList);
  687.   NewList (&SelDevList);
  688.   NewList (&FoundList);
  689.  
  690.   Flags.quit_ff = 0;
  691.  
  692.   if (OpenASysWindow (OpenFindFileWindow, NO_KILL))
  693.     {
  694.       LockMainWindow (WIN_LOCK);
  695.  
  696.       MakeDevList ();
  697.       InitListView (FindFileWnd, FindFileGadgets[GD_DeviceLV - GD_DeviceLV], &DevList, UNSETLVPOS);
  698.  
  699.       do
  700.     {
  701.       Wait (1L << FindFileWnd->UserPort->mp_SigBit);
  702.  
  703.       while ((message = (INTUIMESSAGE *) GT_GetIMsg (FindFileWnd->UserPort)) != NULL)
  704.         {
  705.           object = message->IAddress;
  706.           class = message->Class;
  707.           code = message->Code;
  708.  
  709.           GT_ReplyIMsg (message);
  710.  
  711.           switch (class)
  712.         {
  713.         case IDCMP_GADGETUP:
  714.           HandleFindFileGadgets (object, code);
  715.           break;
  716.  
  717.         case IDCMP_VANILLAKEY:
  718.           HandleFindFileKeys (code);
  719.           break;
  720.  
  721.         case IDCMP_CHANGEWINDOW:
  722.         case IDCMP_REFRESHWINDOW:
  723.           if (NOT (FindFileWnd->Flags & WFLG_ZOOMED))
  724.             {
  725.               /*
  726.                * Das Fenster soll nur EINMAL refreshed werden.
  727.                * Diese IDCMP-Message kommt aber auch dann, wenn ein
  728.                * Fenster verschoben wurde, weshalb ein Flag extra
  729.                * eingeführt wurde.
  730.                */
  731.               if (NOT (refr))
  732.             {
  733.               RefreshRastPort (FindFileWnd, FindFileGadgets, gl, 4, TRUE, NULL);
  734.  
  735.               refr = TRUE;
  736.             }
  737.             }
  738.           else
  739.             refr = FALSE;
  740.  
  741.           MakeWindowRefresh (FindFileWnd);
  742.           break;
  743.  
  744.         case IDCMP_CLOSEWINDOW:
  745.           if (NOT (IsListEmpty (&FoundList)) && Question (FindFileWnd, "File list not empty!\n"
  746.                          "Do you want to save it?", NO))
  747.             SaveFoundFiles ();
  748.  
  749.           Flags.quit_ff = 1;
  750.           break;
  751.         }
  752.         }
  753.     }
  754.       while (NOT (Flags.quit_ff));
  755.  
  756.       FreeRemember (FILEKEY, TRUE);
  757.       FreeRemember (DEVKEY, TRUE);
  758.  
  759.       CloseASysWindow (&FindFileWnd, &FindFileGList, NULL);
  760.  
  761.       LockMainWindow (WIN_UNLOCK);
  762.     }
  763.  
  764.   return;
  765. }
  766.